// 此文件由 SquareLine Studio 生成
// SquareLine Studio 版本: SquareLine Studio 1.5.4
// LVGL 版本: 8.3.11
// 项目名称: First

#include "../ui.h"
#include <stdio.h>
#include <ctype.h>  // 添加这个头文件用于 isdigit 函数

// ============= 全局变量 =============
// 总价格（购物车总价）
double total_price = 0.0;

// ============= 函数前向声明 =============
// 更新总价格函数
void update_total_price(void);
// 重置所有滑块函数
void reset_all_sliders(void);
// 支付后更新用户余额函数
void update_user_balance_after_payment(void);
// 支付按钮事件处理函数
void ui_event_ImgButtonPay(lv_event_t * e);

// ============= 商品列表数据结构 =============
// 饮料商品列表
static P_Node_t FileDrinkList;
// 零食商品列表
static P_Node_t FileSnacksList;
// 以下商品列表未使用（已注释）
// static P_Node_t FileCandyList;    // 糖果商品列表
// static P_Node_t FileCoffeeList;   // 咖啡商品列表
// static P_Node_t FileNoodlesList;  // 面条商品列表

lv_obj_t * ui_SystemForm       = NULL;
lv_obj_t * ui_Panel            = NULL;
lv_obj_t * ui_ContainerTop     = NULL;
lv_obj_t * ui_PanelTop         = NULL;
lv_obj_t * ui_ImgButtonExit    = NULL;
lv_obj_t * ui_ImgButton4       = NULL;
lv_obj_t * ui_ImageTestMid     = NULL;
lv_obj_t * ui_ImgButtonBackto1 = NULL;
lv_obj_t * ui_ImgButtonBackto2 = NULL;
lv_obj_t * ui_ImgButtonBackto3 = NULL;
lv_obj_t * ui_ContainerLeft    = NULL;
lv_obj_t * ui_PanelLeft        = NULL;
lv_obj_t * ui_RollerOption     = NULL;
lv_obj_t * ui_OptionLabel      = NULL;
lv_obj_t * ui_ImageMenupng     = NULL;
lv_obj_t * ui_ContainerRight   = NULL;
lv_obj_t * ui_PanelRTop1       = NULL;
lv_obj_t * ui_PanelRTop2       = NULL;
lv_obj_t * ui_PanelRTop3       = NULL;
// lv_obj_t * ui_PanelRTop4       = NULL;
// lv_obj_t * ui_PanelRTop5       = NULL;

lv_obj_t * ui_Container1     = NULL;
lv_obj_t * ui_Slider1        = NULL;
lv_obj_t * ui_Image1         = NULL;
lv_obj_t * ui_Label1         = NULL;
lv_obj_t * ui_Slider1_Label1 = NULL;

lv_obj_t * ui_Container2     = NULL;
lv_obj_t * ui_Slider2        = NULL;
lv_obj_t * ui_Image2         = NULL;
lv_obj_t * ui_Label2         = NULL;
lv_obj_t * ui_Slider2_Label2 = NULL;

lv_obj_t * ui_Container3     = NULL;
lv_obj_t * ui_Slider3        = NULL;
lv_obj_t * ui_Image3         = NULL;
lv_obj_t * ui_Label3         = NULL;
lv_obj_t * ui_Slider3_Label3 = NULL;

lv_obj_t * ui_Container4     = NULL;
lv_obj_t * ui_Slider4        = NULL;
lv_obj_t * ui_Image4         = NULL;
lv_obj_t * ui_Label4         = NULL;
lv_obj_t * ui_Slider4_Label4 = NULL;

lv_obj_t * ui_Container5     = NULL;
lv_obj_t * ui_Slider5        = NULL;
lv_obj_t * ui_Image5         = NULL;
lv_obj_t * ui_Label5         = NULL;
lv_obj_t * ui_Slider5_Label5 = NULL;

lv_obj_t * ui_Container6     = NULL;
lv_obj_t * ui_Slider6        = NULL;
lv_obj_t * ui_Image6         = NULL;
lv_obj_t * ui_Label6         = NULL;
lv_obj_t * ui_Slider6_Label6 = NULL;

lv_obj_t * ui_Container7     = NULL;
lv_obj_t * ui_Slider7        = NULL;
lv_obj_t * ui_Image7         = NULL;
lv_obj_t * ui_Label7         = NULL;
lv_obj_t * ui_Slider7_Label7 = NULL;

lv_obj_t * ui_Container8     = NULL;
lv_obj_t * ui_Slider8        = NULL;
lv_obj_t * ui_Image8         = NULL;
lv_obj_t * ui_Label8         = NULL;
lv_obj_t * ui_Slider8_Label8 = NULL;

lv_obj_t * ui_Container9     = NULL;
lv_obj_t * ui_Slider9        = NULL;
lv_obj_t * ui_Image9         = NULL;
lv_obj_t * ui_Label9         = NULL;
lv_obj_t * ui_Slider9_Label9 = NULL;

lv_obj_t * ui_Container10      = NULL;
lv_obj_t * ui_Slider10         = NULL;
lv_obj_t * ui_Image10          = NULL;
lv_obj_t * ui_Label10          = NULL;
lv_obj_t * ui_Slider10_Label10 = NULL;

lv_obj_t * ui_PanelRBottom     = NULL;
lv_obj_t * ui_ImgButtonPay     = NULL;
lv_obj_t * ui_ImageCountpng    = NULL;
lv_obj_t * ui_count            = NULL;
lv_obj_t * ui_actionText       = NULL;
lv_obj_t * ui_ImgButtonBalance = NULL;
lv_obj_t * ui_LabelBalance     = NULL;
lv_obj_t * ui_Keyboard1        = NULL;
lv_obj_t * ui_PanelData        = NULL;

/*============= 中文字体样式初始化函数 ============*/
/**
 * @brief 初始化中文字体样式（常规大小）
 * @return 返回指向字体样式的指针
 * @note 使用楷体字体，大小为22，粗体样式
 */
static lv_style_t * FontStyleInit(void)
{
    // 创建字体信息结构体
    static lv_ft_info_t info;
    // FreeType使用C标准文件系统，不需要驱动器盘符
    info.name   = "/usr/share/fonts/simkai.ttf";  // 楷体字体路径
    info.weight = 22;   // 字体大小
    info.style  = FT_FONT_STYLE_BOLD;  // 粗体样式
    info.mem    = NULL;  // 内存指针（NULL表示从文件系统加载）
    // 初始化字体，如果失败则记录错误
    if(!lv_ft_font_init(&info)) {
        LV_LOG_ERROR("create failed.");
    }

    // 使用新字体创建样式
    static lv_style_t style;
    lv_style_init(&style);  // 初始化样式
    lv_style_set_text_font(&style, info.font);  // 设置字体
    lv_style_set_text_align(&style, LV_TEXT_ALIGN_CENTER);  // 设置文本居中对齐

    return &style;
}

/**
 * @brief 使用 LVGL 内置字体创建样式
 * @param font 指向LVGL内置字体的指针
 * @return 返回指向字体样式的指针
 * @note 封装函数，用于创建使用内置字体的样式
 */
static lv_style_t * create_builtin_font_style(const lv_font_t * font)
{
    static lv_style_t style;
    lv_style_init(&style);  // 初始化样式
    lv_style_set_text_font(&style, font);  // 设置内置字体
    return &style;
}




// ============= 事件处理函数 =============
/**
 * @brief 退出按钮事件处理函数
 * @param e 事件对象指针
 * @note 点击退出按钮时，重置购物状态、清除用户信息，并返回到登录界面
 */
void ui_event_ImgButtonExit(lv_event_t * e)
{
    lv_event_code_t event_code = lv_event_get_code(e);  // 获取事件类型

    if(event_code == LV_EVENT_CLICKED) {
        // 退出前重置购物状态
        reset_system_state();

        // 清除当前用户信息
        strcpy(current_username, "");  // 清空用户名
        current_user_balance = 0;      // 重置余额
        // 切换到登录界面（淡入动画）
        _ui_screen_change(&ui_LoginForm, LV_SCR_LOAD_ANIM_FADE_ON, 10, 0, &ui_LoginForm_screen_init);
    }
}

/**
 * @brief 滑块值改变时的回调函数：更新标签文字
 * @param e 事件对象指针
 * @note 当滑块值改变时，更新对应的数量标签文字，并更新总价
 */
static void value_changed_event_cb(lv_event_t * e)
{
    lv_obj_t * ui_Slider = lv_event_get_target(e);    // 获取事件来源（滑块对象）
    lv_obj_t * label     = lv_event_get_user_data(e); // 获取注册时传进来的标签指针

    char buf[16];  // 临时缓冲区
    // 格式化字符串：数量：XXX
    lv_snprintf(buf, sizeof(buf), "数量：%d", (int)lv_slider_get_value(ui_Slider));  // 读取滑块当前值（0-100）
    lv_label_set_text(label, buf);  // 更新标签文字
    lv_obj_align_to(label, ui_Slider, LV_ALIGN_BOTTOM_MID, 0, -10);  // 重新对齐（防止文字变宽后偏移）

    // 直接更新总价
    update_total_price();
}

/**
 * @brief 更新总价显示函数
 * @note 计算所有面板中的商品总价，并更新总价显示标签
 */
void update_total_price(void)
{
    total_price = 0.0;  // 重置总价为0

    // 计算所有面板中的商品总价
    calculate_panel_total(ui_PanelRTop1);  // 计算面板1的总价
    calculate_panel_total(ui_PanelRTop2);  // 计算面板2的总价

    // 更新总价显示
    char total_text[32];
    snprintf(total_text, sizeof(total_text), "总计：%.2f元", total_price);  // 格式化总价文本
    lv_label_set_text(ui_count, total_text);  // 更新总价标签文本
}

/**
 * @brief 计算单个面板的总价函数
 * @param panel 面板对象指针
 * @note 遍历面板中的所有容器，查找每个容器中的滑块和价格标签，
 *       计算每个商品的数量（滑块值）乘以单价，累加到总价中
 */
void calculate_panel_total(lv_obj_t * panel)
{
    // 如果面板对象不存在，直接返回
    if(!panel) return;

    // 获取面板中的所有容器
    uint32_t child_count = lv_obj_get_child_cnt(panel);
    for(uint32_t i = 0; i < child_count; i++) {
        lv_obj_t * container = lv_obj_get_child(panel, i);  // 获取第i个子容器
        if(container) {
            // 在容器中查找滑块和价格标签
            uint32_t container_child_count = lv_obj_get_child_cnt(container);  // 获取容器的子对象数量
            int slider_value               = 0;  // 滑块值（商品数量）
            double item_price              = 0.0;  // 商品单价

            // 遍历容器中的所有子对象
            for(uint32_t j = 0; j < container_child_count; j++) {
                lv_obj_t * container_child = lv_obj_get_child(container, j);  // 获取第j个子对象

                // 查找滑块对象
                if(container_child && lv_obj_check_type(container_child, &lv_slider_class)) {
                    slider_value = lv_slider_get_value(container_child);  // 获取滑块值（商品数量）
                }

                // 查找价格标签（包含价格的标签）
                if(container_child && lv_obj_check_type(container_child, &lv_label_class)) {
                    const char * label_text = lv_label_get_text(container_child);  // 获取标签文本
                    // 检查标签文本是否包含"元"字样，说明是价格标签
                    if(label_text && strstr(label_text, "元") != NULL) {
                        // 从标签文本中提取价格
                        // 格式如："果汁\n5.0元" 或 "5.0元"
                        char * price_start = strstr(label_text, "元");  // 查找"元"字符的位置
                        if(price_start) {
                            // 向前查找数字
                            char * ptr = price_start;
                            while(ptr > label_text && !isdigit((unsigned char)*ptr)) {
                                ptr--;  // 向前移动指针
                            }

                            // 找到数字开始位置
                            if(isdigit((unsigned char)*ptr)) {
                                char * num_end = ptr;
                                // 继续向前查找，找到数字的开始位置
                                while(num_end > label_text && (isdigit((unsigned char)*num_end) || *num_end == '.')) {
                                    num_end--;  // 向前移动指针
                                }
                                num_end++;  // 回到数字开始位置

                                // 提取价格字符串
                                char price_str[32];
                                strncpy(price_str, num_end, ptr - num_end + 1);  // 复制价格字符串
                                price_str[ptr - num_end + 1] = '\0';  // 添加字符串结束符
                                item_price                   = atof(price_str);  // 将价格字符串转换为浮点数
                            }
                        }
                    }
                }
            }

            // 累加商品价格：数量 × 单价
            total_price += slider_value * item_price;
        }
    }
}

/**
 * @brief 选项滚动器事件处理函数
 * @param e 事件对象指针
 * @note 当用户选择不同的商品类别时，显示对应的商品面板，隐藏其他面板
 *       支持"饮料"、"零食"和"更多.."选项
 */
void ui_event_RollerOption(lv_event_t * e)
{
    lv_obj_t * roller      = lv_event_get_target(e);  // 获取滚动器对象
    lv_style_t * fontStyle = FontStyleInit();  // 初始化中文字体格式

    char selected_option[64];  // 存储选中的选项字符串
    lv_roller_get_selected_str(roller, selected_option, sizeof(selected_option));  // 获取选中的选项
    printf("Selected option: %s\n", selected_option);  // 打印选中的选项（调试用）

    // 如果选择的是"饮料"
    if(strcmp(selected_option, "饮料") == 0) {
        lv_obj_clear_flag(ui_PanelRTop1, LV_OBJ_FLAG_HIDDEN);  // 显示饮料面板
        lv_obj_add_flag(ui_PanelRTop2, LV_OBJ_FLAG_HIDDEN);    // 隐藏零食面板

    } 
    // 如果选择的是"零食"
    else if(strcmp(selected_option, "零食") == 0) {
        lv_obj_clear_flag(ui_PanelRTop2, LV_OBJ_FLAG_HIDDEN);  // 显示零食面板
        lv_obj_add_flag(ui_PanelRTop1, LV_OBJ_FLAG_HIDDEN);    // 隐藏饮料面板

    } 
    // 如果选择的是"更多.."
    else if(strcmp(selected_option, "更多..") == 0) {
        lv_obj_add_flag(ui_PanelRTop1, LV_OBJ_FLAG_HIDDEN);  // 隐藏饮料面板
        lv_obj_add_flag(ui_PanelRTop2, LV_OBJ_FLAG_HIDDEN);  // 隐藏零食面板

        // 显示"暂未开放"提示消息框
        lv_obj_t * tip = lv_msgbox_create(NULL, "暂未开放", "敬请期待！", NULL, true);
        lv_obj_align(tip, LV_ALIGN_CENTER, 0, 0);  // 居中显示
        lv_obj_add_style(tip, fontStyle, LV_PART_MAIN);  // 应用中文字体样式
        
        // 设置关闭按钮的字体样式
        lv_obj_t * btn_close         = lv_msgbox_get_close_btn(tip);
        lv_style_t * close_btn_style = create_builtin_font_style(&lv_font_montserrat_22);
        lv_obj_add_style(btn_close, close_btn_style, LV_PART_MAIN);
    }
}

/**
 * @brief 支付按钮事件处理函数
 * @param e 事件对象指针
 * @note 处理支付逻辑：
 *       1. 重新计算总价
 *       2. 检查是否选择了商品
 *       3. 检查余额是否足够
 *       4. 如果余额足够，扣除余额并更新用户数据文件
 *       5. 显示支付成功消息
 *       6. 重置所有滑块和总价显示
 *       7. 更新余额显示
 */
void ui_event_ImgButtonPay(lv_event_t * e)
{
    lv_event_code_t event_code = lv_event_get_code(e);  // 获取事件类型
    lv_style_t * fontStyle     = FontStyleInit();  // 初始化中文字体格式

    if(event_code == LV_EVENT_CLICKED) {
        // 重新计算总价确保准确
        update_total_price();

        // 检查是否选择了商品
        if(total_price <= 0) {
            // 没有选择商品，显示提示消息框
            lv_obj_t * tip = lv_msgbox_create(NULL, "提示", "请先选择商品！", NULL, true);
            lv_obj_align(tip, LV_ALIGN_CENTER, 0, 0);  // 居中显示
            lv_obj_add_style(tip, fontStyle, LV_PART_MAIN);  // 应用中文字体样式
            
            // 设置关闭按钮的字体样式
            lv_obj_t * btn_close         = lv_msgbox_get_close_btn(tip);
            lv_style_t * close_btn_style = create_builtin_font_style(&lv_font_montserrat_22);
            lv_obj_add_style(btn_close, close_btn_style, LV_PART_MAIN);
            return;  // 没有选择商品，退出函数
        }

        // 检查余额是否足够
        if(total_price > current_user_balance) {
            // 余额不足，显示错误提示消息框
            char msg[64];
            snprintf(msg, sizeof(msg), "余额不足！\n需要：%.2f元\n余额：%d元", total_price, current_user_balance);  // 格式化错误消息
            lv_obj_t * tip = lv_msgbox_create(NULL, "支付失败", msg, NULL, true);
            lv_obj_align(tip, LV_ALIGN_CENTER, 0, 0);  // 居中显示
            lv_obj_add_style(tip, fontStyle, LV_PART_MAIN);  // 应用中文字体样式
            
            // 设置关闭按钮的字体样式
            lv_obj_t * btn_close         = lv_msgbox_get_close_btn(tip);
            lv_style_t * close_btn_style = create_builtin_font_style(&lv_font_montserrat_22);
            lv_obj_add_style(btn_close, close_btn_style, LV_PART_MAIN);
            return;  // 余额不足，退出函数
        }

        // 余额足够，进行支付
        update_user_balance_after_payment();

        // 显示支付成功消息
        char success_msg[64];
        snprintf(success_msg, sizeof(success_msg), "\n消费：%.2f元\n剩余余额：%d元", total_price, current_user_balance);  // 格式化成功消息
        lv_obj_t * tip = lv_msgbox_create(NULL, "支付成功!", success_msg, NULL, true);
        lv_obj_align(tip, LV_ALIGN_CENTER, 0, 0);  // 居中显示
        lv_obj_add_style(tip, fontStyle, LV_PART_MAIN);  // 应用中文字体样式
        
        // 设置关闭按钮的字体样式
        lv_obj_t * btn_close         = lv_msgbox_get_close_btn(tip);
        lv_style_t * close_btn_style = create_builtin_font_style(&lv_font_montserrat_22);
        lv_obj_add_style(btn_close, close_btn_style, LV_PART_MAIN);

        // 重置所有滑块
        reset_all_sliders();

        // 更新总价显示为0
        total_price = 0.0;  // 重置总价
        lv_label_set_text(ui_count, "总计：0.00元");  // 更新总价标签文本

        // 更新余额显示
        update_balance_display();
    }
}

/**
 * @brief 支付后更新用户余额函数
 * @note 扣除用户的消费金额，并更新用户数据文件
 *       通过创建临时文件的方式更新用户余额，确保数据安全
 */
void update_user_balance_after_payment(void)
{
    // 扣除消费金额（将总价转换为整数后扣除）
    current_user_balance -= (int)total_price;

    // 以只读模式打开用户数据文件
    FILE * file = fopen("/jakl/img/UserData.txt", "r");
    if(!file) {
        printf("无法打开用户数据文件\n");
        return;  // 文件打开失败，退出函数
    }

    // 以写入模式创建临时文件
    FILE * temp_file = fopen("/jakl/img/UserData_temp.txt", "w");
    if(!temp_file) {
        fclose(file);  // 关闭原文件
        printf("无法创建临时文件\n");
        return;  // 临时文件创建失败，退出函数
    }

    char line[256];      // 存储文件中的一行数据
    char username[50];   // 存储从文件读取的用户名
    char password[50];   // 存储从文件读取的密码
    int balance;         // 存储从文件读取的余额

    // 复制文件内容，更新当前用户的余额
    while(fgets(line, sizeof(line), file)) {
        // 解析每行数据：用户名 密码 余额
        if(sscanf(line, "%s %s %d", username, password, &balance) == 3) {
            // 如果是当前用户
            if(strcmp(username, current_username) == 0) {
                // 写入更新后的用户余额
                fprintf(temp_file, "%s %s %d\n", username, password, current_user_balance);
            } else {
                // 保持其他用户信息不变
                fputs(line, temp_file);
            }
        } else {
            // 保持格式错误的行或注释行不变
            fputs(line, temp_file);
        }
    }

    fclose(file);      // 关闭原文件
    fclose(temp_file); // 关闭临时文件

    // 替换原文件
    remove("/jakl/img/UserData.txt");  // 删除原文件
    rename("/jakl/img/UserData_temp.txt", "/jakl/img/UserData.txt");  // 将临时文件重命名为原文件

    printf("用户 %s 余额已更新为：%d\n", current_username, current_user_balance);
}

/**
 * @brief 重置所有滑块为0函数
 * @note 重置所有面板中的滑块值为0，并将总价显示重置为0.00元
 */
void reset_all_sliders(void)
{
    printf("开始重置所有滑块...\n");

    int reset_count = 0;  // 重置计数器
    reset_count += reset_panel_sliders(ui_PanelRTop1);  // 重置面板1中的滑块
    reset_count += reset_panel_sliders(ui_PanelRTop2);  // 重置面板2中的滑块

    // 强制更新总价显示
    total_price = 0.0;  // 重置总价为0
    if(ui_count) {
        lv_label_set_text(ui_count, "总计：0.00元");  // 更新总价标签文本
    }

    printf("成功重置了 %d 个滑块，总价已归零\n", reset_count);
}

/**
 * @brief 重置单个面板中的所有滑块函数
 * @param panel 面板对象指针
 * @return 返回重置的滑块数量
 * @note 遍历面板中的所有容器，查找滑块对象并将其值重置为0
 */
int reset_panel_sliders(lv_obj_t * panel)
{
    // 如果面板对象不存在，返回0
    if(!panel) return 0;

    int reset_count      = 0;  // 重置计数器
    uint32_t child_count = lv_obj_get_child_cnt(panel);  // 获取面板的子对象数量

    // 遍历面板中的所有子对象（容器）
    for(uint32_t i = 0; i < child_count; i++) {
        lv_obj_t * child = lv_obj_get_child(panel, i);  // 获取第i个子容器
        if(child) {
            uint32_t container_child_count = lv_obj_get_child_cnt(child);  // 获取容器的子对象数量
            // 遍历容器中的所有子对象
            for(uint32_t j = 0; j < container_child_count; j++) {
                lv_obj_t * container_child = lv_obj_get_child(child, j);  // 获取第j个子对象
                // 如果子对象是滑块类型
                if(container_child && lv_obj_check_type(container_child, &lv_slider_class)) {
                    // 重置滑块值为0（带动画）
                    lv_slider_set_value(container_child, 0, LV_ANIM_ON);

                    // 手动触发值改变事件来更新标签
                    lv_event_send(container_child, LV_EVENT_VALUE_CHANGED, NULL);

                    reset_count++;  // 增加重置计数
                    break;  // 每个容器只有一个滑块，找到后跳出循环
                }
            }
        }
    }

    return reset_count;  // 返回重置的滑块数量
}

/**
 * @brief 创建UI容器函数（动态创建商品容器）
 * @param index 容器索引（用于生成唯一对象名称）
 * @param parent 父容器对象指针
 * @param img_path 商品图片路径
 * @param label_text 商品名称标签文本
 * @param slider_label_text 滑块标签文本（显示数量）
 * @note 动态创建一个商品容器，包含：
 *       - 商品图片
 *       - 商品名称标签
 *       - 数量滑块
 *       - 数量显示标签
 */
void create_ui_container(uint8_t index, lv_obj_t * parent, const char * img_path, const char * label_text,
                         const char * slider_label_text)
{
    // 初始化中文字体格式
    lv_style_t * fontStyle = FontStyleInit();

    // 定义对象名称缓冲区（用于动态生成对象名称，但实际未使用）
    char container_name[20];
    char slider_name[20];
    char image_name[20];
    char label_name[20];
    char slider_label_name[20];

    // 动态生成对象名称（实际未使用，仅用于调试）
    snprintf(container_name, sizeof(container_name), "ui_Container%d", index);
    snprintf(slider_name, sizeof(slider_name), "ui_Slider%d", index);
    snprintf(image_name, sizeof(image_name), "ui_Image%d", index);
    snprintf(label_name, sizeof(label_name), "ui_Label%d", index);
    snprintf(slider_label_name, sizeof(slider_label_name), "ui_Slider%d_Label", index);

    // ============= 创建商品容器 =============
    lv_obj_t * container = lv_obj_create(parent);  // 使用传入的父容器创建容器对象
    lv_obj_remove_style_all(container);  // 移除所有默认样式
    lv_obj_set_width(container, 200);   // 设置容器宽度
    lv_obj_set_height(container, 300);  // 设置容器高度
    lv_obj_set_x(container, -123);      // 设置容器X坐标
    lv_obj_set_y(container, -85);       // 设置容器Y坐标
    lv_obj_set_align(container, LV_ALIGN_CENTER);  // 设置对齐方式为居中
    lv_obj_clear_flag(container, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE);  // 清除可点击和可滚动标志

    // ============= 创建数量滑块 =============
    lv_obj_t * slider = lv_slider_create(container);
    lv_slider_set_value(slider, 0, LV_ANIM_OFF);  // 设置滑块初始值为0（无动画）
    // 如果滑块是范围模式，设置左值也为0
    if(lv_slider_get_mode(slider) == LV_SLIDER_MODE_RANGE) lv_slider_set_left_value(slider, 0, LV_ANIM_OFF);
    lv_obj_set_width(slider, 120);   // 设置滑块宽度
    lv_obj_set_height(slider, 10);   // 设置滑块高度
    lv_obj_set_x(slider, 0);         // 设置滑块X坐标
    lv_obj_set_y(slider, -14);       // 设置滑块Y坐标
    lv_obj_set_align(slider, LV_ALIGN_BOTTOM_MID);  // 设置对齐方式为底部中间
    lv_arc_set_value(slider, 0);  // 设置滑块值（如果支持圆弧模式）

    // ============= 创建商品图片 =============
    lv_obj_t * image = lv_img_create(container);
    lv_img_set_src(image, img_path);  // 使用传入的图片路径设置图片源
    lv_obj_set_width(image, LV_SIZE_CONTENT);   // 设置图片宽度为内容自适应
    lv_obj_set_height(image, LV_SIZE_CONTENT);  // 设置图片高度为内容自适应
    lv_obj_set_align(image, LV_ALIGN_TOP_MID);  // 设置对齐方式为顶部中间
    lv_obj_set_x(image, 0);   // 设置图片X坐标
    lv_obj_set_y(image, -4);  // 设置图片Y坐标
    lv_obj_add_flag(image, LV_OBJ_FLAG_ADV_HITTEST);   // 添加高级命中测试标志
    lv_obj_clear_flag(image, LV_OBJ_FLAG_SCROLLABLE);  // 清除可滚动标志

    // ============= 创建商品名称标签 =============
    lv_obj_t * label = lv_label_create(container);
    lv_obj_set_width(label, LV_SIZE_CONTENT);   // 设置标签宽度为内容自适应
    lv_obj_set_height(label, LV_SIZE_CONTENT);  // 设置标签高度为内容自适应
    lv_obj_set_x(label, 0);   // 设置标签X坐标
    lv_obj_set_y(label, -4);  // 设置标签Y坐标
    lv_obj_set_align(label, LV_ALIGN_TOP_LEFT);  // 设置对齐方式为顶部左侧

    lv_label_set_text(label, label_text);  // 使用传入的文本内容设置标签文本

    lv_obj_add_style(label, fontStyle, 0);  // 应用中文字体样式
    lv_obj_set_style_text_color(label, lv_color_hex(0xFFFF00), LV_PART_MAIN | LV_STATE_DEFAULT);  // 设置文本颜色（黄色）
    lv_obj_set_style_text_opa(label, 255, LV_PART_MAIN | LV_STATE_DEFAULT);  // 设置文本不透明度

    // ============= 创建数量显示标签 =============
    lv_obj_t * slider_label = lv_label_create(container);
    lv_obj_set_width(slider_label, LV_SIZE_CONTENT);   // 设置标签宽度为内容自适应
    lv_obj_set_height(slider_label, LV_SIZE_CONTENT);  // 设置标签高度为内容自适应
    lv_obj_set_x(slider_label, 0);    // 设置标签X坐标
    lv_obj_set_y(slider_label, -24);  // 设置标签Y坐标
    lv_obj_set_align(slider_label, LV_ALIGN_BOTTOM_MID);  // 设置对齐方式为底部中间
    lv_label_set_text(slider_label, slider_label_text);  // 使用传入的文本内容设置标签文本
    lv_obj_add_style(slider_label, fontStyle, 0);  // 应用中文字体样式
    lv_obj_set_style_text_color(slider_label, lv_color_hex(0xCC6CE7), LV_PART_MAIN | LV_STATE_DEFAULT);  // 设置文本颜色（紫色）
    lv_obj_set_style_text_opa(slider_label, 255, LV_PART_MAIN | LV_STATE_DEFAULT);  // 设置文本不透明度

    // ============= 注册事件处理 =============
    // 手动触发一次 VALUE_CHANGED 事件，让标签初始显示与滑块同步
    lv_event_send(slider, LV_EVENT_VALUE_CHANGED, NULL);
    // 注册事件：当滑块值改变时，调用回调函数，并把数量标签作为用户数据传进去
    lv_obj_add_event_cb(slider, value_changed_event_cb, LV_EVENT_VALUE_CHANGED, slider_label);
}

/**
 * @brief 从文件更新链表数据函数
 * @param head 链表头节点指针
 * @param fileName 数据文件路径
 * @note 从文件中读取商品数据（名称和价格），更新到链表中
 *       文件格式：第一行是表头，后续每行格式为"编号 名称 价格"
 */
void UpdateListWithFileData(P_Node_t head, const char * fileName)
{
    // 以只读模式打开文件
    FILE * file = fopen(fileName, "r");
    if(file == NULL) {
        perror("Failed to open file");  // 如果文件打开失败，打印错误信息并返回
        return;  // 文件打开失败，退出函数
    }

    // 定义一个缓冲区，用于存储每一行的内容
    char line[1024];

    // 跳过表头（假设文件的第一行是表头，如"编号 名称 价格"）
    fgets(line, sizeof(line), file);

    // 初始化链表指针，指向链表的第一个数据节点
    P_Node_t tmp = head->Next;

    // 逐行读取文件内容
    while(fgets(line, sizeof(line), file) && tmp != head) {
        // 使用 strtok 分割每一行的内容，以空格为分隔符
        char * token = strtok(line, " ");
        if(token == NULL) continue;  // 如果当前行为空，跳过

        // 跳过编号（假设文件的第一列是编号，我们不需要它）
        token = strtok(NULL, " ");
        if(token == NULL) continue;  // 如果没有名称字段，跳过

        // 将名称字段复制到链表节点的 Name 字段
        strncpy(tmp->Data.Name, token, sizeof(tmp->Data.Name) - 1);  // 复制商品名称
        tmp->Data.Name[sizeof(tmp->Data.Name) - 1] = '\0';  // 确保字符串以 null 结尾

        // 获取价格字段
        token = strtok(NULL, " ");
        if(token == NULL) continue;  // 如果没有价格字段，跳过

        // 将价格字段转换为 double 类型，并存储到链表节点的 Price 字段
        tmp->Data.Price = atof(token);  // 将价格字符串转换为浮点数

        // 移动到链表的下一个节点
        tmp = tmp->Next;
    }

    // 关闭文件
    fclose(file);
}

/**
 * @brief 系统界面加载完成后的回调函数
 * @param e 事件对象指针
 * @note 当系统界面加载完成后，更新余额显示
 */
void on_system_form_loaded(lv_event_t * e)
{
    // 更新余额显示
    update_balance_display();
}

/**
 * @brief 更新余额显示的函数
 * @note 根据当前用户名更新余额标签的显示内容
 *       如果用户已登录，显示余额；如果未登录，显示"--"
 */
void update_balance_display(void)
{
    if(ui_LabelBalance) {
        char balance_text[32];
        // 如果用户已登录
        if(strlen(current_username) > 0) {
            // 格式化余额文本：余额：XXX元
            snprintf(balance_text, sizeof(balance_text), "余额：%d元", current_user_balance);
        } else {
            // 如果用户未登录，显示"--"
            snprintf(balance_text, sizeof(balance_text), "余额：--");
        }
        lv_label_set_text(ui_LabelBalance, balance_text);  // 更新余额标签文本
    }
}

/**
 * @brief 强制重置所有滑块的定时器回调函数
 * @param timer 定时器对象指针
 * @note 用于在定时器触发时强制重置所有滑块和总价显示
 */
void force_reset_all_sliders(lv_timer_t * timer)
{
    printf("强制重置所有滑块和状态...\n");
    reset_all_sliders();  // 重置所有滑块
    total_price = 0.0;    // 重置总价
    lv_label_set_text(ui_count, "总计：0.00元");  // 更新总价标签文本
    lv_timer_del(timer);  // 删除定时器
}

/**
 * @brief 系统表单屏幕初始化函数
 * @note 创建并初始化系统界面的所有UI组件，包括：
 *       - 初始化商品数据链表（饮料和零食）
 *       - 检索商品图片文件
 *       - 读取商品数据文件
 *       - 创建UI界面（顶部面板、左侧菜单、右侧商品面板等）
 */
void ui_SystemForm_screen_init(void)
{
    // ============= 初始化系统状态 =============
    // 在函数开头强制重置所有状态
    total_price = 0.0;  // 重置总价为0

    // ============= 初始化商品数据链表 =============
    // 初始化饮料商品链表
    FileDrinkList = InitNewNode(NULL);
    if(FileDrinkList == NULL) {
        perror("FileDrinkList Init Error!");  // 初始化失败，打印错误信息
    }
    printf("初始化文件链表FileDrinkList成功！\n正在读取数据....\n");

    // 初始化零食商品链表
    FileSnacksList = InitNewNode(NULL);
    if(FileSnacksList == NULL) {
        perror("FileSnacksList Init Error!");  // 初始化失败，打印错误信息
    }
    printf("初始化文件链表FileSnacksList成功！\n正在读取数据....\n");

    // ============= 检索商品图片文件 =============
    // 检索饮料目录中的图片文件
    int retVal = DirRetrieval("/jakl/img/drink/", ".png", FileDrinkList);
    if(retVal < 0) {
        perror("DirRetrieval failed");  // 检索失败，打印错误信息
    } else {
        printf("检索/jakl/img/drink/有%d个图片文件\n", retVal);
    }
    
    // 检索零食目录中的图片文件
    retVal = DirRetrieval("/jakl/img/snacks/", ".png", FileSnacksList);
    if(retVal < 0) {
        perror("DirRetrieval failed");  // 检索失败，打印错误信息
    } else {
        printf("检索/jakl/img/snacks/有%d个图片文件\n", retVal);
    }

    // ============= 读取商品数据文件 =============
    // 从文件读取饮料商品数据
    UpdateListWithFileData(FileDrinkList, "/jakl/img/drink/DrinkData.txt");
    // 从文件读取零食商品数据
    UpdateListWithFileData(FileSnacksList, "/jakl/img/snacks/SnacksData.txt");

    // 打印商品列表（调试用）
    myprintf(FileDrinkList);
    myprintf(FileSnacksList);

    // ============= 初始化中文字体格式 =============
    // 初始化中文格式
    lv_style_t * fontStyle = FontStyleInit();

    ui_SystemForm = lv_obj_create(NULL);
    lv_obj_clear_flag(ui_SystemForm, LV_OBJ_FLAG_SCROLLABLE); /// Flags
    lv_obj_set_style_bg_color(ui_SystemForm, lv_color_hex(0xFFFFFF), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_bg_opa(ui_SystemForm, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_Panel = lv_obj_create(ui_SystemForm);
    lv_obj_set_width(ui_Panel, 800);
    lv_obj_set_height(ui_Panel, 480);
    lv_obj_set_align(ui_Panel, LV_ALIGN_CENTER);
    lv_obj_clear_flag(ui_Panel, LV_OBJ_FLAG_SCROLLABLE); /// Flags
    lv_obj_set_style_bg_color(ui_Panel, lv_color_hex(0x6C757D), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_bg_opa(ui_Panel, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_ContainerTop = lv_obj_create(ui_Panel);
    lv_obj_remove_style_all(ui_ContainerTop);
    lv_obj_set_width(ui_ContainerTop, 770);
    lv_obj_set_height(ui_ContainerTop, 60);
    lv_obj_set_x(ui_ContainerTop, 0);
    lv_obj_set_y(ui_ContainerTop, -195);
    lv_obj_set_align(ui_ContainerTop, LV_ALIGN_CENTER);
    lv_obj_clear_flag(ui_ContainerTop, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_PanelTop = lv_obj_create(ui_ContainerTop);
    lv_obj_set_width(ui_PanelTop, 770);
    lv_obj_set_height(ui_PanelTop, 60);
    lv_obj_set_x(ui_PanelTop, 0);
    lv_obj_set_y(ui_PanelTop, 1);
    lv_obj_set_align(ui_PanelTop, LV_ALIGN_CENTER);
    lv_obj_clear_flag(ui_PanelTop, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE); /// Flags
    lv_obj_set_style_bg_color(ui_PanelTop, lv_color_hex(0x9EC7FD), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_bg_opa(ui_PanelTop, 255, LV_PART_MAIN | LV_STATE_DEFAULT);



    ui_ImgButtonExit = lv_imgbtn_create(ui_PanelTop);
    lv_imgbtn_set_src(ui_ImgButtonExit, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_704042566, NULL);
    lv_obj_set_width(ui_ImgButtonExit, 46);
    lv_obj_set_height(ui_ImgButtonExit, 54);
    lv_obj_set_x(ui_ImgButtonExit, 0);
    lv_obj_set_y(ui_ImgButtonExit, 3);
    lv_obj_set_align(ui_ImgButtonExit, LV_ALIGN_RIGHT_MID);

    ui_ImgButton4 = lv_imgbtn_create(ui_PanelTop);
    lv_imgbtn_set_src(ui_ImgButton4, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_1319330495, NULL);
    lv_obj_set_width(ui_ImgButton4, 49);
    lv_obj_set_height(ui_ImgButton4, 48);
    lv_obj_set_x(ui_ImgButton4, 180);
    lv_obj_set_y(ui_ImgButton4, 0);
    lv_obj_set_align(ui_ImgButton4, LV_ALIGN_LEFT_MID);

    ui_ImageTestMid = lv_img_create(ui_PanelTop);
    lv_img_set_src(ui_ImageTestMid, &ui_img_fbhnldans1_png);
    lv_obj_set_width(ui_ImageTestMid, LV_SIZE_CONTENT);  /// 1
    lv_obj_set_height(ui_ImageTestMid, LV_SIZE_CONTENT); /// 1
    lv_obj_set_x(ui_ImageTestMid, 0);
    lv_obj_set_y(ui_ImageTestMid, 4);
    lv_obj_set_align(ui_ImageTestMid, LV_ALIGN_CENTER);
    lv_obj_add_flag(ui_ImageTestMid, LV_OBJ_FLAG_ADV_HITTEST);  /// Flags
    lv_obj_clear_flag(ui_ImageTestMid, LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_ImgButtonBackto1 = lv_imgbtn_create(ui_PanelTop);
    lv_imgbtn_set_src(ui_ImgButtonBackto1, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_891835627, NULL);
    lv_obj_set_width(ui_ImgButtonBackto1, 49);
    lv_obj_set_height(ui_ImgButtonBackto1, 48);
    lv_obj_set_x(ui_ImgButtonBackto1, -180);
    lv_obj_set_y(ui_ImgButtonBackto1, 0);
    lv_obj_set_align(ui_ImgButtonBackto1, LV_ALIGN_RIGHT_MID);

    ui_ImgButtonBackto2 = lv_imgbtn_create(ui_PanelTop);
    lv_imgbtn_set_src(ui_ImgButtonBackto2, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_151540245, NULL);
    lv_obj_set_width(ui_ImgButtonBackto2, 49);
    lv_obj_set_height(ui_ImgButtonBackto2, 48);
    lv_obj_set_x(ui_ImgButtonBackto2, -120);
    lv_obj_set_y(ui_ImgButtonBackto2, 0);
    lv_obj_set_align(ui_ImgButtonBackto2, LV_ALIGN_RIGHT_MID);

    ui_ImgButtonBackto3 = lv_imgbtn_create(ui_PanelTop);
    lv_imgbtn_set_src(ui_ImgButtonBackto3, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_449914792, NULL);
    lv_obj_set_width(ui_ImgButtonBackto3, 49);
    lv_obj_set_height(ui_ImgButtonBackto3, 48);
    lv_obj_set_x(ui_ImgButtonBackto3, 120);
    lv_obj_set_y(ui_ImgButtonBackto3, 0);
    lv_obj_set_align(ui_ImgButtonBackto3, LV_ALIGN_LEFT_MID);

    ui_ContainerLeft = lv_obj_create(ui_Panel);
    lv_obj_remove_style_all(ui_ContainerLeft);
    lv_obj_set_width(ui_ContainerLeft, 130);
    lv_obj_set_height(ui_ContainerLeft, 400);
    lv_obj_set_x(ui_ContainerLeft, -319);
    lv_obj_set_y(ui_ContainerLeft, 29);
    lv_obj_set_align(ui_ContainerLeft, LV_ALIGN_CENTER);
    lv_obj_clear_flag(ui_ContainerLeft, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_PanelLeft = lv_obj_create(ui_ContainerLeft);
    lv_obj_set_width(ui_PanelLeft, 130);
    lv_obj_set_height(ui_PanelLeft, 390);
    lv_obj_set_x(ui_PanelLeft, 0);
    lv_obj_set_y(ui_PanelLeft, 5);
    lv_obj_set_align(ui_PanelLeft, LV_ALIGN_CENTER);
    lv_obj_clear_flag(ui_PanelLeft, LV_OBJ_FLAG_SCROLLABLE); /// Flags
    lv_obj_set_style_bg_color(ui_PanelLeft, lv_color_hex(0x9EC7FD), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_bg_opa(ui_PanelLeft, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_RollerOption = lv_roller_create(ui_PanelLeft);
    lv_roller_set_options(ui_RollerOption, "饮料\n零食\n更多..", LV_ROLLER_MODE_NORMAL);
    lv_obj_add_style(ui_RollerOption, fontStyle, 0);
    lv_obj_set_style_text_color(ui_RollerOption, lv_color_hex(0x8291FF), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_text_opa(ui_RollerOption, 255, LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_height(ui_RollerOption, 340);
    lv_obj_set_width(ui_RollerOption, LV_SIZE_CONTENT); /// 140
    lv_obj_set_x(ui_RollerOption, 0);
    lv_obj_set_y(ui_RollerOption, 12);
    lv_obj_set_align(ui_RollerOption, LV_ALIGN_BOTTOM_MID);

    ui_OptionLabel = lv_label_create(ui_PanelLeft);
    lv_label_set_long_mode(ui_OptionLabel,
                           LV_LABEL_LONG_SCROLL_CIRCULAR); // 当文本长度超过标签宽度时，文本会以循环滚动的方式显示
    lv_obj_set_width(ui_OptionLabel, 60);                  /// 1
    lv_obj_set_height(ui_OptionLabel, LV_SIZE_CONTENT);    /// 1
    lv_obj_set_x(ui_OptionLabel, 4);
    lv_obj_set_y(ui_OptionLabel, -10);
    lv_obj_set_align(ui_OptionLabel, LV_ALIGN_TOP_RIGHT);
    lv_label_set_text(ui_OptionLabel, "全部分类");
    lv_obj_add_style(ui_OptionLabel, fontStyle, 0);
    lv_obj_set_style_text_color(ui_OptionLabel, lv_color_hex(0xFFC582), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_text_opa(ui_OptionLabel, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_ImageMenupng = lv_img_create(ui_PanelLeft);
    lv_img_set_src(ui_ImageMenupng, &ui_img_1331580518);
    lv_obj_set_width(ui_ImageMenupng, LV_SIZE_CONTENT);  /// 32
    lv_obj_set_height(ui_ImageMenupng, LV_SIZE_CONTENT); /// 32
    lv_obj_set_x(ui_ImageMenupng, -10);
    lv_obj_set_y(ui_ImageMenupng, -16);
    lv_obj_add_flag(ui_ImageMenupng, LV_OBJ_FLAG_ADV_HITTEST);  /// Flags
    lv_obj_clear_flag(ui_ImageMenupng, LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_ContainerRight = lv_obj_create(ui_Panel);
    lv_obj_remove_style_all(ui_ContainerRight);
    lv_obj_set_width(ui_ContainerRight, 635);
    lv_obj_set_height(ui_ContainerRight, 400);
    lv_obj_set_x(ui_ContainerRight, 66);
    lv_obj_set_y(ui_ContainerRight, 35);
    lv_obj_set_align(ui_ContainerRight, LV_ALIGN_CENTER);
    lv_obj_clear_flag(ui_ContainerRight, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_PanelRTop1 = lv_obj_create(ui_ContainerRight);
    lv_obj_set_width(ui_PanelRTop1, 635);
    lv_obj_set_height(ui_PanelRTop1, 320);
    lv_obj_set_x(ui_PanelRTop1, -1);
    lv_obj_set_y(ui_PanelRTop1, 3);
    lv_obj_set_align(ui_PanelRTop1, LV_ALIGN_TOP_MID);
    lv_obj_set_flex_flow(ui_PanelRTop1, LV_FLEX_FLOW_ROW);
    lv_obj_set_flex_align(ui_PanelRTop1, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
    lv_obj_set_scrollbar_mode(ui_PanelRTop1, LV_SCROLLBAR_MODE_OFF);
    lv_obj_set_scroll_dir(ui_PanelRTop1, LV_DIR_HOR);
    lv_obj_set_style_bg_color(ui_PanelRTop1, lv_color_hex(0xD4E3FD), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_bg_opa(ui_PanelRTop1, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    int Container_Count = 0;
    char msg[256]       = {0};
    for(P_Node_t tmp = FileDrinkList->Next; tmp != FileDrinkList; tmp = tmp->Next) {
        Container_Count++;
        snprintf(msg, sizeof(msg), "%s\n%.1f元", tmp->Data.Name, tmp->Data.Price);
        create_ui_container(Container_Count, ui_PanelRTop1, tmp->Data.FilePath, msg, "数量：0");
    }

    // 创建 ui_PanelRTop2
    ui_PanelRTop2 = lv_obj_create(ui_ContainerRight);
    if(ui_PanelRTop2 == NULL) {
        printf("Failed to create ui_PanelRTop2\n");
    } else {
        printf("ui_PanelRTop2 created successfully\n");
    }
    lv_obj_set_width(ui_PanelRTop2, 635);
    lv_obj_set_height(ui_PanelRTop2, 320);
    lv_obj_set_x(ui_PanelRTop2, -1);
    lv_obj_set_y(ui_PanelRTop2, 3);
    lv_obj_set_align(ui_PanelRTop2, LV_ALIGN_TOP_MID);
    lv_obj_set_flex_flow(ui_PanelRTop2, LV_FLEX_FLOW_ROW);
    lv_obj_set_flex_align(ui_PanelRTop2, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
    lv_obj_set_scrollbar_mode(ui_PanelRTop2, LV_SCROLLBAR_MODE_OFF);
    lv_obj_set_scroll_dir(ui_PanelRTop2, LV_DIR_HOR);
    lv_obj_set_style_bg_color(ui_PanelRTop2, lv_color_hex(0xD4E3FD), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_bg_opa(ui_PanelRTop2, 255, LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_add_flag(ui_PanelRTop2, LV_OBJ_FLAG_HIDDEN);

    // 设置 ui_PanelRTop2 为隐藏

    for(P_Node_t tmp = FileSnacksList->Next; tmp != FileSnacksList; tmp = tmp->Next) {
        Container_Count++;
        snprintf(msg, sizeof(msg), "%s\n%.1f元", tmp->Data.Name, tmp->Data.Price);
        create_ui_container(Container_Count, ui_PanelRTop2, tmp->Data.FilePath, msg, "数量：0");
    }

    ui_PanelRBottom = lv_obj_create(ui_ContainerRight);
    lv_obj_set_width(ui_PanelRBottom, 635);
    lv_obj_set_height(ui_PanelRBottom, 70);
    lv_obj_set_x(ui_PanelRBottom, -1);
    lv_obj_set_y(ui_PanelRBottom, -5);
    lv_obj_set_align(ui_PanelRBottom, LV_ALIGN_BOTTOM_MID);
    lv_obj_clear_flag(ui_PanelRBottom, LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_ImgButtonPay = lv_imgbtn_create(ui_PanelRBottom);
    lv_imgbtn_set_src(ui_ImgButtonPay, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_2090553937, NULL);
    lv_obj_set_width(ui_ImgButtonPay, 50);
    lv_obj_set_height(ui_ImgButtonPay, 47);
    lv_obj_set_align(ui_ImgButtonPay, LV_ALIGN_RIGHT_MID);

    ui_ImageCountpng = lv_img_create(ui_PanelRBottom);
    lv_img_set_src(ui_ImageCountpng, &ui_img_693980214);
    lv_obj_set_width(ui_ImageCountpng, LV_SIZE_CONTENT);  /// 48
    lv_obj_set_height(ui_ImageCountpng, LV_SIZE_CONTENT); /// 48
    lv_obj_set_x(ui_ImageCountpng, -65);
    lv_obj_set_y(ui_ImageCountpng, 0);
    lv_obj_set_align(ui_ImageCountpng, LV_ALIGN_CENTER);
    lv_obj_add_flag(ui_ImageCountpng, LV_OBJ_FLAG_ADV_HITTEST);  /// Flags
    lv_obj_clear_flag(ui_ImageCountpng, LV_OBJ_FLAG_SCROLLABLE); /// Flags

    ui_count = lv_label_create(ui_PanelRBottom);
    lv_obj_set_width(ui_count, LV_SIZE_CONTENT);  /// 1
    lv_obj_set_height(ui_count, LV_SIZE_CONTENT); /// 1
    lv_obj_set_x(ui_count, 40);
    lv_obj_set_y(ui_count, 0);
    lv_obj_set_align(ui_count, LV_ALIGN_CENTER);
    lv_label_set_text(ui_count, "总计：0.00元");
    lv_obj_add_style(ui_count, fontStyle, 0);
    lv_obj_set_style_text_color(ui_count, lv_color_hex(0x00FA9A), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_text_opa(ui_count, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_actionText = lv_label_create(ui_PanelRBottom);
    lv_obj_set_width(ui_actionText, 100);  /// 1
    lv_obj_set_height(ui_actionText, LV_SIZE_CONTENT); /// 1
    lv_obj_set_align(ui_actionText, LV_ALIGN_CENTER);
    lv_obj_set_x(ui_actionText, -70);
    lv_obj_set_y(ui_actionText, 0);
    lv_obj_set_align(ui_actionText, LV_ALIGN_RIGHT_MID);
    // 设置滚动文本
    lv_label_set_long_mode(ui_actionText, LV_LABEL_LONG_SCROLL_CIRCULAR); // 循环滚动
    lv_label_set_text(ui_actionText, "结算请点击购物车");
    lv_obj_add_style(ui_actionText, fontStyle, 0);
    lv_obj_set_style_text_color(ui_actionText, lv_color_hex(0xFF6347), LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_ImgButtonBalance = lv_imgbtn_create(ui_PanelRBottom);
    lv_imgbtn_set_src(ui_ImgButtonBalance, LV_IMGBTN_STATE_RELEASED, NULL, &ui_img_1182893005, NULL);
    lv_obj_set_width(ui_ImgButtonBalance, 47);
    lv_obj_set_height(ui_ImgButtonBalance, 49);
    lv_obj_set_align(ui_ImgButtonBalance, LV_ALIGN_LEFT_MID);

    ui_LabelBalance = lv_label_create(ui_PanelRBottom);
    lv_obj_set_width(ui_LabelBalance, LV_SIZE_CONTENT);  /// 1
    lv_obj_set_height(ui_LabelBalance, LV_SIZE_CONTENT); /// 1
    lv_obj_set_x(ui_LabelBalance, 50);
    lv_obj_set_y(ui_LabelBalance, 0);
    lv_obj_set_align(ui_LabelBalance, LV_ALIGN_LEFT_MID);
    lv_label_set_text(ui_LabelBalance, "余额：");

    // 使用全局变量显示余额
    char balance_text[32];


    if(strlen(current_username) > 0) {
        snprintf(balance_text, sizeof(balance_text), "余额：%d元", current_user_balance);
    } else {
        snprintf(balance_text, sizeof(balance_text), "余额：--");
    }
    lv_label_set_text(ui_LabelBalance, balance_text);

    lv_obj_add_style(ui_LabelBalance, fontStyle, 0);
    lv_obj_set_style_text_color(ui_LabelBalance, lv_color_hex(0x00FA9A), LV_PART_MAIN | LV_STATE_DEFAULT);
    lv_obj_set_style_text_opa(ui_LabelBalance, 255, LV_PART_MAIN | LV_STATE_DEFAULT);

    ui_Keyboard1 = lv_keyboard_create(ui_SystemForm);
    lv_obj_set_width(ui_Keyboard1, 500);
    lv_obj_set_height(ui_Keyboard1, 250);
    lv_obj_set_align(ui_Keyboard1, LV_ALIGN_BOTTOM_MID);
    lv_obj_add_flag(ui_Keyboard1, LV_OBJ_FLAG_HIDDEN); /// Flags

    ui_PanelData = lv_obj_create(ui_SystemForm);
    lv_obj_set_width(ui_PanelData, 500);
    lv_obj_set_height(ui_PanelData, 400);
    lv_obj_set_align(ui_PanelData, LV_ALIGN_CENTER);
    lv_obj_add_flag(ui_PanelData, LV_OBJ_FLAG_HIDDEN);                               /// Flags
    lv_obj_clear_flag(ui_PanelData, LV_OBJ_FLAG_CLICKABLE | LV_OBJ_FLAG_SCROLLABLE); /// Flags

  
    lv_obj_add_event_cb(ui_ImgButtonExit, ui_event_ImgButtonExit, LV_EVENT_ALL, NULL);
    lv_obj_add_event_cb(ui_RollerOption, ui_event_RollerOption, LV_EVENT_VALUE_CHANGED, NULL);
    // 添加屏幕加载事件监听
    lv_obj_add_event_cb(ui_SystemForm, on_system_form_loaded, LV_EVENT_SCREEN_LOADED, NULL);
    lv_obj_add_event_cb(ui_ImgButtonPay, ui_event_ImgButtonPay, LV_EVENT_CLICKED, NULL);

    // 在初始化完成后强制重置所有滑块
    lv_timer_create(force_reset_all_sliders, 100, NULL);

    printf("系统界面初始化完成，用户: %s, 余额: %d\n", current_username, current_user_balance);
}

// 重置系统状态
void reset_system_state(void)
{
    printf("重置系统状态...\n");

    // 重置总价
    total_price = 0.0;

    // 重置所有滑块
    reset_all_sliders();

    // 重置显示
    if(ui_count) {
        lv_label_set_text(ui_count, "总计：0.00元");
    }

    // 重置用户选择状态（如果有的话）
    // 这里可以添加其他需要重置的状态

    printf("系统状态重置完成\n");
}

/**
 * @brief 系统表单屏幕销毁函数
 * @note 删除系统表单屏幕对象，并将所有UI对象指针设置为NULL，防止野指针
 */
void ui_SystemForm_screen_destroy(void)
{
    // 如果系统表单对象存在，则删除它
    if(ui_SystemForm) lv_obj_del(ui_SystemForm);

    // ============= 将所有UI对象指针设置为NULL，防止野指针 =============
    ui_SystemForm       = NULL;
    ui_Panel            = NULL;
    ui_ContainerTop     = NULL;
    ui_PanelTop         = NULL;

    ui_ImgButtonExit    = NULL;
    ui_ImgButton4       = NULL;
    ui_ImageTestMid     = NULL;
    ui_ImgButtonBackto1 = NULL;
    ui_ImgButtonBackto2 = NULL;
    ui_ImgButtonBackto3 = NULL;
    ui_ContainerLeft    = NULL;
    ui_PanelLeft        = NULL;
    ui_RollerOption     = NULL;
    ui_OptionLabel      = NULL;
    ui_ImageMenupng     = NULL;
    ui_ContainerRight   = NULL;
    ui_PanelRTop1       = NULL;
    ui_PanelRTop2       = NULL;
    ui_PanelRTop3       = NULL;
    // ui_PanelRTop4       = NULL;
    // ui_PanelRTop5       = NULL;

    ui_Container1       = NULL;
    ui_Slider1          = NULL;
    ui_Image1           = NULL;
    ui_Label1           = NULL;
    ui_Slider1_Label1   = NULL;
    ui_Container2       = NULL;
    ui_Slider2          = NULL;
    ui_Image2           = NULL;
    ui_Label2           = NULL;
    ui_Container3       = NULL;
    ui_Slider3          = NULL;
    ui_Image3           = NULL;
    ui_Label3           = NULL;
    ui_Container4       = NULL;
    ui_Slider4          = NULL;
    ui_Image4           = NULL;
    ui_Label4           = NULL;
    ui_PanelRBottom     = NULL;
    ui_ImgButtonPay     = NULL;
    ui_ImageCountpng    = NULL;
    ui_count            = NULL;
    ui_actionText       = NULL;
    ui_ImgButtonBalance = NULL;
    ui_LabelBalance     = NULL;
    ui_Keyboard1        = NULL;
    ui_PanelData        = NULL;
}
